Fzzy Config/me.fzzyhmstrs.fzzy_config.validation.collection/ValidatedList

ValidatedList

open class ValidatedList<T>(defaultValue: List<T>, entryHandler: Entry<T, *>) : ValidatedField<List<T>> , List<T>

a validated list

This ValidatedField implements List, so you can directly use it as if it were an immutable list

Author

fzzyhmstrs

Since

0.1.0

Parameters

any non-null type

defaultValue

default list of values

entryHandler

Entry used to handle individual list entries

Samples

import me.fzzyhmstrs.fzzy_config.util.EnumTranslatable
import me.fzzyhmstrs.fzzy_config.validation.Shorthand.validated
import me.fzzyhmstrs.fzzy_config.validation.collection.*
import me.fzzyhmstrs.fzzy_config.validation.minecraft.ValidatedIdentifier
import me.fzzyhmstrs.fzzy_config.validation.misc.ValidatedBoolean
import me.fzzyhmstrs.fzzy_config.validation.misc.ValidatedString
import me.fzzyhmstrs.fzzy_config.validation.number.ValidatedInt
import net.minecraft.registry.RegistryKeys
import net.minecraft.util.Identifier

fun main() { 
   //sampleStart 
   //validated int list, with validation on entries restricting inputs to 1 to 16 (inclusive)
val validatedList = ValidatedList(listOf(1, 2, 4, 8), ValidatedInt(1..16))

//wraps the vararg valued provided with a blank validated field (identifiers in this case). validation with actual bounds and logic can of course be used too
val listFromFieldVararg = ValidatedIdentifier().toList(Identifier.of("stick"), Identifier.of("blaze_rod"))

//wraps the collection provided with a blank validated field (identifiers in this case). validation with actual bounds and logic can of course be used too
val listFromFieldCollection = ValidatedIdentifier().toList(listOf(Identifier.of("wooden_sword"), Identifier.of("stone_sword")))

//fields and sections have lang keys based on their "location" in the Config class graph.
//Lange key composition is as follows
//1. the namespace of the config id: (my_mod)
//2. the path of the config id: (my_mod.my_config)
//3. any parent ConfigSection field names as declared in-code: (my_mod.my_config.subSection)
//4. the setting field name as declared in-code: (my_mod.my_config.subSection.fieldName)
val fieldLang = """
{
    "_comment1": "the lang for an example 'fieldName' setting in a config inside section 'subSection'",
    "my_mod.my_config.subSection.fieldName": "Very Important Setting",
    "my_mod.my_config.subSection.fieldName.desc": "This very important setting is used in this very important way."
}
""" 
   //sampleEnd
}

Constructors

ValidatedList

constructor(defaultValue: List<T>, entryHandler: Entry<T, *>)

Types

Companion

object Companion

Properties

size

open override val size: Int

Functions

open override fun accept(input: List<T>)

updates the wrapped value. NOTE: this method will push updates to an UpdateManager, if any. For in-game updating consider validateAndSet

addFirst

open override fun addFirst(p0: T)

addLast

open override fun addLast(p0: T)

addListener

open fun addListener(listener: Consumer<ValidatedField<List<T>>>)

Attaches a listener to this field. This listener will be called any time the field is written to ("set"). accept, validateAndSet, setAndUpdate and so on will all call the listener.

andThen

open fun andThen(p0: Consumer<in List<T>>): Consumer<List<T>>

codec

fun codec(): Codec<List<T>>

Provides a Codec representing the value type of this validation, backed by the validators within as applicable

contains

open operator override fun contains(element: T): Boolean

containsAll

open override fun containsAll(elements: Collection<T>): Boolean

copyStoredValue

open override fun copyStoredValue(): List<T>

Creates a deep copy of the stored value and returns it

description

open fun description(fallback: String? = null): MutableText

The translated Text description from the descriptionKey. Falls back to an empty string so no tooltip is rendered.

descriptionKey

open override fun descriptionKey(): String

translation key of this Translatable's description. the "description" in-game, the descriptions Enchantment Descriptions adds to enchantment tooltips are a good example.

flags

open fun flags(): Byte

forEach

open fun forEach(p0: Consumer<in T>)

get

open override fun get(): List<T>

supplies the wrapped value

open operator override fun get(index: Int): T

getDefault

fun getDefault(): List<T>

Provides this validations default value

getFirst

open override fun ~~getFirst~~(): T

getLast

open override fun ~~getLast~~(): T

hasDescription

open fun hasDescription(): Boolean

Whether this Translatable has a valid description

hasFlag

open override fun hasFlag(flag: EntryFlag.Flag): Boolean

hasTranslation

open fun hasTranslation(): Boolean

Whether this Translatable has a valid translation

indexOf

open override fun indexOf(element: T): Int

instanceEntry

open override fun instanceEntry(): ValidatedList<T>

creates a deep copy of this ValidatedList return ValidatedList wrapping a deep copy of the currently stored list and passes the entry handler

isEmpty

open override fun isEmpty(): Boolean

iterator

open operator override fun iterator(): Iterator<T>

lastIndexOf

open override fun lastIndexOf(element: T): Int

listIterator

open override fun listIterator(): ListIterator<T>

open override fun listIterator(index: Int): ListIterator<T>

map

fun <N> map(to: Function<List<T>, out N>, from: Function<in N, List<T>>): ValidatedField<N>

Maps this validation to a new convertible type. The default value will be applied from this delegates current storedValue

fun <N> map(defaultValue: N, to: Function<List<T>, out N>, from: Function<in N, List<T>>): ValidatedField<N>

fun <N> map(to: Function<List<T>, out N>, from: Function<in N, List<T>>, defaultValue: List<T>): ValidatedField<N>

Maps this validation to a new convertible type.

parallelStream

open fun parallelStream(): Stream<T>

removeFirst

open override fun removeFirst(): T

removeLast

open override fun removeLast(): T

reversed

open override fun reversed(): MutableList<T>

spliterator

open override fun spliterator(): Spliterator<T>

stream

open fun stream(): Stream<T>

subList

open override fun subList(fromIndex: Int, toIndex: Int): List<T>

supply

fun <T> List<T>.supply(): Supplier<List<T>>

wraps a list in a Supplier

toArray

open fun <T : Any> ~~toArray~~(p0: IntFunction<Array<T>>): Array<T>

toChoices

@JvmOverloads

fun toChoices(widgetType: ValidatedChoice.WidgetType = WidgetType.POPUP, translationProvider: BiFunction<T, String, MutableText> = BiFunction { t, _ -> t.transLit(t.toString()) }, descriptionProvider: BiFunction<T, String, Text> = BiFunction { t, _ -> t.descLit("") }): ValidatedChoice<T>

Converts this ValidatedList into ValidatedChoice wrapping this list as the valid choice options

toCondition

open fun toCondition(condition: ValidatedField<Boolean>, fallback: Supplier<List<T>>): ValidatedCondition<List<T>>

Convert this field to a ValidatedCondition using the provided validation as a supplier. The provided condition (and any others you append) must pass for the stored value to be provided, otherwise the fallback will be supplied.

open fun toCondition(condition: ValidatedCondition.Condition, fallback: Supplier<List<T>>): ValidatedCondition<List<T>>

open fun toCondition(condition: Supplier<Boolean>, failMessage: Text, fallback: Supplier<List<T>>): ValidatedCondition<List<T>>

Convert this field to a ValidatedCondition. The provided condition (and any others you append) must pass for the stored value to be provided, otherwise the fallback will be supplied.

open fun toCondition(scope: String, failMessage: Text, fallback: Supplier<List<T>>): ValidatedCondition<List<T>>

Convert this field to a ValidatedCondition using the provided scope with a default boolean provider. The provided condition (and any others you append) must pass for the stored value to be provided, otherwise the fallback will be supplied. The provided scope must point to a valid boolean config scope otherwise the initial condition will never pass.

toList

fun toList(vararg elements: List<T>): ValidatedList<List<T>>

wraps the provided values into a ValidatedList with this field as validation

fun toList(collection: Collection<List<T>>): ValidatedList<List<T>>

wraps the provided collection into a ValidatedList with this field as validation

toSet

fun toSet(vararg elements: List<T>): ValidatedSet<List<T>>

wraps the provided values into a ValidatedSet with this field as validation

fun toSet(collection: Collection<List<T>>): ValidatedSet<List<T>>

wraps the provided collection into a ValidatedSet with this field as validation

translation

open override fun translation(fallback: String?): MutableText

The translated Text name from the translationKey. Falls back to the implementing classes Simple Name (non-translated)

translationKey

open override fun translationKey(): String

translation key of this Translatable. the "name" in-game

trySerialize

fun trySerialize(input: Any?, errorBuilder: MutableList<String>, flags: Byte): TomlElement?

trySet

open override fun trySet(input: Any?)

update

open fun update(updateMessage: Text)

validateAndSet

open fun validateAndSet(input: List<T>): ValidationResult<List<T>>

A setter method for the storedValue that first validates the value being set and then stores the post-validation result.

validateAndSetFlagged

open fun validateAndSetFlagged(input: List<T>, vararg flag: EntryFlag.Flag): ValidationResult<List<T>>

A setter method for the storedValue that first validates the value being set and then stores the post-validation result.

validated

@JvmStatic

inline fun <T : Number> List<T>.validated(): ValidatedList<T>

Shorthand validated number List

@JvmStatic

fun <T : Any> List<T>.validated(handler: Entry<T, *>): ValidatedList<T>

Shorthand validated List

validatedIds

@JvmStatic

fun List<Identifier>.~~validatedIds~~(): ValidatedIdentifier

Shorthand Validated Identifier using the List for validation

validatedList

@JvmStatic

fun List<Identifier>.~~validatedList~~(list: List<Identifier>): ValidatedList<Identifier>

Shorthand Validated Identifier List, validated with a list

validatedRegistry

@JvmStatic

fun <T : Any> List<Identifier>.validatedRegistry(registry: Registry<T>): ValidatedList<Identifier>

Shorthand Validated Identifier List, validated with a registry

@JvmStatic

fun <T : Any> List<Identifier>.validatedRegistry(registry: Registry<T>, predicate: BiPredicate<Identifier, RegistryEntry<T>>): ValidatedList<Identifier>

Shorthand Validated Identifier List, validated with a predicated registry

validatedTag

@JvmStatic

fun List<Identifier>.validatedTag(tagKey: TagKey<*>): ValidatedList<Identifier>

Shorthand Validated Identifier List, validated with a tag

widgetAndTooltipEntry

open fun widgetAndTooltipEntry(choicePredicate: ChoiceValidator<List<T>> = ChoiceValidator.any()): ClickableWidget

ValidatedList

Author

Since

Parameters

See also

Samples

Constructors

Types

Properties

Functions